﻿var gameDao = require("./../dao/gameDao");
var gameConfig = require("./../config/gameConfig")
var redis_laba_win_pool = require("./../../util/redis_laba_win_pool")
let log = require("./../../util/loginfo").getInstand;

arithmetic = function (_idx) {
	//相关属性
	//调试是否显示相关数据
	var debug = false;

	//算法说明：
	//本算法说明，先选中组合，然后再尝试他的概率。
	//所有击中的bet
	//可选择倍数
	var betCountObj = {};
	betCountObj[1] = 1;
	betCountObj[2] = 2;
	betCountObj[5] = 3;
	betCountObj[10] = 4;
	betCountObj[20] = 5;
	betCountObj[50] = 6;
	betCountObj[100] = 7;
	var betCount = [1, 10, 20, 50, 100];


	//pro 能整除最大值
	this.pro_max = new Array();
	//pro 个数
	this.pro_max_count = new Array();
	//外部控制倍率
	this.controlBet = 0.98;
	//超级大奖占成
	this.poolBet = 0.01;
	//最大公约数
	this.max_pro = 0;

	this._testMax = 0;

	//分数数组
	this.scoreArr = {};

	//虚拟奖池
	this.virtual_score_pool = 1000000;
	//实际奖池
	this.score_pool = [];

	//========================================
	//水位
	this.nGamblingWaterLevelGold = 0;
	//库存
	this.nGamblingBalanceGold = 0;
	//奖池
	this.nGamblingWinPool = 0;
	//大奖幸运等级
	this.nGamblingBigWinLevel = [];
	//大奖幸运概率
	this.nGamblingBigWinLuck = [];

	this.printPool = function () {
		for (var i = 0; i < betCount.length; ++i) {
			log.info("i:" + i + "-" + this.score_pool[i]);
		}
	};

	//获得实际奖池
	this.getScorePool = function (_betIdx) {
		if (this.score_pool[_betIdx]) {
			this.printPool();
			return this.score_pool[_betIdx];
		} else {
			//this.printPool();
			return 0
		}

	};

	this.getScorePoolList = function () {
		return this.score_pool;
	};

	this.getScorePoolListLength = function () {
		return betCount.length;
	};

	this.getScoreId = function () {
		return betCount;
	};


	this.getGamblingBalanceGold = function () {
		//获取库存 奖池   数据库同步使用
		var dict = {
			nGamblingBalanceGold: this.nGamblingBalanceGold,
			nGamblingWinPool: this.nGamblingWinPool
		};

		return dict;

	};
	this.addGamblingBalanceGold = function (Gold, Pool) {
		//添加库存 奖池   数据库同步使用
		this.nGamblingBalanceGold += parseInt(Gold);
		this.nGamblingWinPool += parseInt(Pool);
		log.info("添加库存:" + Gold);
		log.info("添加奖池:" + Pool);
		log.info(this.nGamblingBalanceGold);
		log.info(this.nGamblingWinPool);
		//redis存储奖池
		redis_laba_win_pool.redis_win_pool_incrby(parseInt(Pool))
	};
	this.subGamblingBalanceGold = function (Gold, Pool) {
		//减少库存   奖池 数据库同步使用
		//this.nGamblingBalanceGold-= parseInt(Gold);
		this.nGamblingWinPool -= parseInt(Pool);
		log.info("减少库存:" + Gold);
		log.info("减少奖池:" + Pool);
		log.info(this.nGamblingBalanceGold);
		log.info(this.nGamblingWinPool);

		//redis减少奖池
		redis_laba_win_pool.redis_win_pool_decrby(parseInt(Pool));
	};
	this.getGamblingBalanceLevelBigWin = function () {
		//获取库存  水位 奖池 幸运值   判断中奖使用
		var value = {
			nGamblingWaterLevelGold: this.nGamblingWaterLevelGold,
			nGamblingBalanceGold: this.nGamblingBalanceGold,
			nGamblingWinPool: this.nGamblingWinPool,
			nGamblingBigWinLevel: this.nGamblingBigWinLevel,
			nGamblingBigWinLuck: this.nGamblingBigWinLuck
		};
		return value;
	};

	//添加实际奖池
	this.addScorePool = function (_betIdx, _socre) {
		if (this.score_pool[_betIdx]) {
			this.score_pool[_betIdx] += parseInt(_socre);
		} else {
			this.score_pool[_betIdx] = 0;
			this.score_pool[_betIdx] += parseInt(_socre);
		}

		this.printPool();
	};

	//减少奖池
	this.subScorePool = function (_betIdx) {
		if (this.score_pool[_betIdx]) {
			this.score_pool[_betIdx] -= this.subValue;
		} else {
			this.score_pool[_betIdx] = 0;
		}
		this.printPool();
	};

	this.getAllcaishenValue = function () {
		//获得全财神的值
		return this.subValue;
	};

	//获得奖池
	this.getVirtualScorePool = function () {
		//var result = {virtual_score_pool:this.virtual_score_pool,score_pool}
		return this.virtual_score_pool;
	};

	//添加奖池
	this.addVirtualScorePool = function (score_bet) {
		this.virtual_score_pool += parseInt(score_bet);
	};

	//减少虚拟奖池
	this.subVirtualScorePool = function (score_bet, flag) {
		this.subValue = Math.floor((this.virtual_score_pool / 100 * score_bet * 0.9));
		//log.info(score_bet)
		//log.info(this.virtual_score_pool)
		//log.info(this.subValue)
		if (flag) {
			this.virtual_score_pool -= this.subValue;
		} else {
			if (this.virtual_score_pool - this.subValue > 900000 || this.virtual_score_pool > 2000000) {
				this.virtual_score_pool -= this.subValue;
			}
		}

	};

	this.init = function () {
		//初始化水位和库存
		this.initGamblingGame();
	};

	this.initPool = function () {
		var self = this;

		gameDao.getScore_pools(function (Result) {

			for (var i = 0; i < Result.length; ++i) {
				if (Result[i].id == 0) {
					self.virtual_score_pool = Result[i].score_pool;
				} else {
					for (var j = 0; j < betCount.length; ++j) {
						if (betCount[j] == Result[i].id) {
							self.score_pool[j] = Result[i].score_pool;
							break;
						}
					}
				}
			}

			log.info("读取采池数据完毕!")
		})


	};


	//获得当前概率
	this.getBet = function () {
		return this.controlBet;
	};

	//设置概率
	this.setBet = function (_bet) {
		this.controlBet = _bet;
	};


	this.CheckBet = function (_betIdx) {
		return betCount[_betIdx];
	};

	this.Check_bet_dict = function (bet_dict) {
		//检查下注字典
		// if ([0,1,2,3,4,5,6,7].indexOf(bet_dict.bet_type)==-1) {
		//     log.info("缺少字段bet_type");
		//     return false;
		// }
		if ([0, 1, 2].indexOf(bet_dict.bet_res) == -1) {
			log.info("缺少字段bet_res");
			return false;
		}
		if (bet_dict.bet_gold == undefined || bet_dict.bet_gold == null || bet_dict.bet_gold == 0) {
			log.info("缺少字段bet_gold");
			return false;
		}
		return true
	};

	//=================================================================================================
	this.initGamblingGame = function () {
		var self = this;
		gameDao.getGamblingGame(function (Result) {

			self.nGamblingWaterLevelGold = Result[0].nGamblingWaterLevelGold;  //水位
			self.nGamblingBalanceGold = Result[0].nGamblingBalanceGold;      //库存
			self.nGamblingWinPool = Result[0].nGamblingWinPool;      //奖池

			self.nGamblingBigWinLevel = Result[0].nGamblingBigWinLevel.split(',').map(Number);  //大奖幸运等级
			self.nGamblingBigWinLuck = Result[0].nGamblingBigWinLuck.split(',').map(Number);    //大奖幸运概率

			// //redis存储奖池
			// redis_laba_win_pool.redis_win_pool_incrby(self.nGamblingWinPool)


			log.info("读取采池数据完毕!");
			log.info("水位:" + self.nGamblingWaterLevelGold);
			log.info("库存:" + self.nGamblingBalanceGold);
			log.info("奖池:" + self.nGamblingWinPool);
			// log.info("大奖幸运等级:" + self.nGamblingBigWinLevel);
			// log.info("大奖幸运概率:" + self.nGamblingBigWinLuck);
		})

	};

	this.gameProcessor = function (betInfo_list, nGamblingWinPool) {
		// ZZZ-20230513,
		let bet_list = [0, 0]; // 下注金额数组
		let all_bet_sort = [[0, 0], [1, 0]]; // 排序下注数组
		let pay_bet_list = []; // 能够赔付的数组
		let bet_all = 0; // 总共下注

		for (let i in betInfo_list) {
			let betInfo = betInfo_list[i];    //下注详情
			let idx = parseInt(betInfo.bet_res);
			let bet = parseInt(betInfo["bet_gold"]);

			if (betInfo["isRobot"]) {
				continue;
			}
			bet_all += bet;
			bet_list[idx] += bet;
			all_bet_sort[idx][1] += (bet * gameConfig.GAME_LONG_HU_DOU_ODDS[idx]);
		}
		// 按照赔付金额从小到大排序
		all_bet_sort.sort(function(a, b) {
			return (a[1] > b[1]) ? 1 : -1;
		});
		for (let i in all_bet_sort) {
			let idx = all_bet_sort[i][0];
			let pay = all_bet_sort[i][1];
			let bet = bet_list[idx];

			if (pay <= 0 || pay <= (nGamblingWinPool/100)) { // 金额占比很小
				pay_bet_list.push(idx);
			} else {
				if (pay <= (nGamblingWinPool/10)) { // 奖金要留有余量
					if ((bet / bet_all) <= 0.85) { // 消除峰值
						pay_bet_list.push(idx);
						log.info("idx=" + idx + ", <= 0.85, pushed");
					}
				} else {
					if (Math.abs(pay - bet_all) <= (bet_all*0.15)) { // 有差不多可以对冲的数额
						pay_bet_list.push(idx);
						log.info("idx=" + idx + ", <= 0.15, pushed");
					}
				}
			}
		}
		log.info("gameProcessor all_bet_sort=" + JSON.stringify(all_bet_sort));
		log.info("gameProcessor pay_bet_list=" + JSON.stringify(pay_bet_list));

		//决定结果
		let win_index = 0;
		// 赔付判断
		if (pay_bet_list.length <= 1) { // 都不够赔付或仅有一个，选最小的
			win_index = all_bet_sort[0][0];
			log.info("~~~~~~~~~~~~~~~ 都不够赔付，选最小的，代号 = " + win_index + ", 金额 = " + all_bet_sort[0][1]);
		} else {
			// 两个都够赔付，在这里面随机选
			win_index = RandomNumBoth(0, 1);
		}

		//算账
		var user_win_list = {};    //用户赢钱字典
		var user_bet_sum_list = {};  //用户下注数字典
		var user_bet_true_list = [];  //用户压对数组
		var user_robot_dict = {};  //是否机器人字典
		for (let i in betInfo_list) {
			let betInfo = betInfo_list[i];    //下注详情
			let res = parseInt(betInfo.bet_res);
			if (!user_win_list[betInfo["userId"]]) {
				user_win_list[betInfo["userId"]] = 0;
			}
			if (!user_bet_sum_list[betInfo["userId"]]) {
				user_bet_sum_list[betInfo["userId"]] = 0;
			}
			user_bet_sum_list[betInfo["userId"]] += parseInt(betInfo["bet_gold"]);

			if (res === win_index) {
				if (user_bet_true_list.indexOf(betInfo["userId"]) === -1) {
					user_bet_true_list.push(betInfo["userId"]);
				}
				user_win_list[betInfo["userId"]] += parseInt(betInfo["bet_gold"]) * gameConfig.GAME_LONG_HU_DOU_ODDS[res];
			}

			user_robot_dict[betInfo["userId"]] = betInfo["is_robot"];
		}

		log.info("win_index = " + win_index + ", user_win_list = " + JSON.stringify(user_win_list));

		//开奖算法
		var dictAnalyseResults = {};

		dictAnalyseResults["win"] = win_index;
		dictAnalyseResults["win_user_list"] = user_win_list;  //# 用户获奖结果
		dictAnalyseResults["user_bet_sum_list"] = user_bet_sum_list;  //用户下注字典
		dictAnalyseResults["user_bet_true_list"] = user_bet_true_list;  //用户神算子数组
		dictAnalyseResults["user_robot_dict"] = user_robot_dict;  //是否机器人数组

		return dictAnalyseResults
	};

	this.init();

};


function RandomNumForList(arr) {
	//从指定数组中选取随机值
	return arr[Math.floor((Math.random() * arr.length))]

}

function RandomNumBoth(Min, Max) {
	//生成指定范围内随机整数
	var Range = Max - Min;
	var Rand = Math.random();
	var num = Min + Math.round(Rand * Range); //四舍五入
	return num;
}

function getNumber(nCard) {
	//获取牌的牌数(扑克用)
	return parseInt(parseInt(nCard / 16) / 16)
}


module.exports = arithmetic;